home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / lang / PPCsmalltalk.lha / PPCSmallTalk / sources / lex.c < prev    next >
C/C++ Source or Header  |  1986-10-19  |  6KB  |  287 lines
  1. /*
  2.     Little Smalltalk lexical analyzer for driver 
  3.         timothy a. budd 12/84
  4. */
  5. /*
  6.     The source code for the Little Smalltalk System may be freely
  7.     copied provided that the source of all files is acknowledged
  8.     and that this condition is copied with each file.
  9.  
  10.     The Little Smalltalk System is distributed without responsibility
  11.     for the performance of the program and without any guarantee of
  12.     maintenance.
  13.  
  14.     All questions concerning Little Smalltalk should be addressed to:
  15.  
  16.         Professor Tim Budd
  17.         Department of Computer Science
  18.         The University of Arizona
  19.         Tucson, Arizona
  20.         85721
  21.         USA
  22. */
  23. # include <stdio.h>
  24. # include <ctype.h>
  25. # include <math.h>
  26. # define DRIVECODE
  27. # include "drive.h"
  28.  
  29. # define MAXTOKEN 100
  30. char toktext[MAXTOKEN];
  31. tok_type t;
  32. int token;
  33.  
  34. extern char *lexptr;
  35. extern double atof();
  36.  
  37. static char ocbuf = 0;
  38. static int pbbuf[20];
  39.  
  40. # define input() (ocbuf ? pbbuf[--ocbuf] : *lexptr++ )
  41. # define putbak(c) (pbbuf[ocbuf++] = c)
  42.  
  43. static char *psuvars[] = {"nil", "true", "false", "smalltalk", 0};
  44. static int psuval[] = {nilvar, truevar, falsevar, smallvar};
  45. static char symbols[] = "\n-()[]!|.;>" ;
  46. static int symval[] = {NL, MINUS, LP, RP, LB, RB, BAR, BAR, 
  47.     PERIOD, SEMI, PE};
  48.  
  49. static int lexsave(type)
  50. int type;
  51. {    char *w_search();
  52.  
  53.     if (! (t.c = w_search(toktext, 1)))
  54.         lexerr("cannot create symbol %s", toktext);
  55.     /* assign token, and return value */
  56.     return(token = type);
  57. }
  58.  
  59. int nextlex() {
  60.     register char c;
  61.     register char *p;
  62.     char *q;
  63.     int  i, n, base;
  64.     double d, denom;
  65.  
  66.     do {            /* read whitespace (including comments) */
  67.         c = input();
  68.         if (c == '\"') {
  69.             while ((c = input()) && c != '\"') ;
  70.             if (c == '\"') c = input();
  71.             else lexerr("unterminated comment", "");
  72.             }
  73.         } while (c == ' ' || c == '\t') ;
  74.  
  75.     if (!c) return(token = nothing);
  76.  
  77.     p = toktext;
  78.     *p = c;
  79.     toktext[1] = '\0';
  80.  
  81.                         /* identifiers and keywords */
  82.     if (( c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
  83.         for (*p++ = c; (c = input()) && isalnum(c) ; *p++ = c) ;
  84.         *p = '\0';
  85.         lexsave(0);
  86.         if (c == ':') {
  87.             return(token = KEYWORD);
  88.             }
  89.         else {
  90.             putbak(c);
  91.             if (islower(toktext[0])) {
  92.                 for (i = 0; psuvars[i]; i++)
  93.                     if (strcmp(toktext, psuvars[i]) == 0) {
  94.                         t.p = psuval[i];
  95.                         return(token = PSEUDO);
  96.                         }
  97.                 return(token = LOWERCASEVAR);
  98.                 }
  99.             else {
  100.                 return(token = UPPERCASEVAR);
  101.                 }
  102.             }
  103.         }
  104.     
  105. # define scandigits(x) for(*p++ = c; (c = input()) && isdigit(c); *p++ = c) x
  106.  
  107.     if (c >= '0' && c <= '9') {        /* numbers */
  108.         i = c - '0';
  109.         scandigits( i = 10 * i + (c - '0') );
  110.         if (c == '.' || c == 'e') {
  111.             if (c == '.') {
  112.                 /* peek at the next char to make sure */
  113.                 n = input(); putbak(n);
  114.                 if (! isdigit(n)) goto ret_int;
  115.                 scandigits(0);
  116.                 }
  117.             if (c == 'e') {
  118.                 *p++ = c;
  119.                 c = input();
  120.                 if (c == '+' || c == '-') {
  121.                     *p++ = c; c = input(); }
  122.                 scandigits(0);
  123.                 }
  124.             putbak(c);
  125.             *p = '\0';
  126.             t.f = atof(toktext);
  127.             return(token = LITFNUM);
  128.             }
  129.         else if ((c == 'r') && ((i >= 2) && (i <= 36))) {
  130.             base = i;
  131.             i = 0;
  132.             for (*p++ = c; c = input(); *p++ = c) {
  133.                 if (isdigit(c)) n = c - '0';
  134.                 else if (isupper(c)) n = (c - 'A') + 10;
  135.                 else break;
  136.                 if (n >= base) break;
  137.                 i = base * i + n;
  138.                 }
  139.             if (c == '.' || c == 'e') {
  140.                 d = (double) i;
  141.                 if (c == '.') {
  142.  
  143.                     /* just peek at the next char */
  144.                     n = input(); putbak(n);
  145.                     if ((! isdigit(n)) && (! isupper(n))) 
  146.                         goto ret_int;
  147.  
  148.                     denom = 1.0 / (double) base;
  149.                     for (*p++ = c; c = input(); *p++ = c) {
  150.                         if (isdigit(c))
  151.                             n = c - '0';
  152.                         else if (isupper(c))
  153.                             n = (c - 'A') + 10;
  154.                         else break;
  155.                         if (n >= base) break;
  156.                         d += n * denom;
  157.                         denom /= base;
  158.                         }
  159.                     }
  160.                 if (c == 'e') {
  161.                     *p++ = c;
  162.                     c = input();
  163.                     if (c == '+' || c == '-') {
  164.                         n = c;
  165.                         *p++ = c;
  166.                         c = input();
  167.                         }
  168.                     else n = 0;
  169.                     i = c - '0';
  170.                     scandigits(i = 10 * i + (c - '0'));
  171.                     if (n == '-') i = - i;
  172.                     d *= pow((double) base, (double) i);
  173.                     }
  174.                 putbak(c);
  175.                 *p = '\0';
  176.                 t.f = d;
  177.                 return(token = LITFNUM);
  178.                 }
  179.             }
  180.  
  181.     ret_int:
  182.         putbak(c);
  183.         *p = '\0';
  184.         t.i = i;
  185.         return(token = LITNUM);
  186.         }
  187.  
  188.     if (c == '#') {                /* symbol */
  189.         i = 1;
  190.         while (i)
  191.             switch(c = input()) {
  192.                 case '\0': case ' ': case '\t': case '\n':
  193.                 case '(': case '[': case ')':
  194.                     putbak(c);
  195.                     i = 0;
  196.                     break;
  197.                 default:
  198.                     *p++ = c;
  199.                 }
  200.         if (p == toktext)
  201.             return(token = PS);
  202.         else {
  203.             *p = '\0';
  204.             if ((p - toktext) >= MAXTOKEN) cant_happen(18);
  205.             return(lexsave(LITSYM));
  206.             }
  207.         }
  208.  
  209.     if (c == '\'') {            /* quoted string */
  210.         do {
  211.             for ( ; (c = input()) && c != '\'' ; *p++ = c) ;
  212.             c = input();
  213.             if (c == '\'') *p++ = '\'';
  214.             } while (c == '\'');
  215.         putbak(c);
  216.         *p = '\0';
  217.         if ((p - toktext) >= MAXTOKEN) cant_happen(18);
  218.         t.c = toktext;
  219.         return(token = LITSTR);
  220.         }
  221.  
  222.     if (c == ':') {                /* colon or argument name */
  223.         c = input();
  224.         if (c == '=') 
  225.             return(token = ASSIGN);
  226.         else if (isalnum(c)) {
  227.             for (*p++ = c; isalnum(c = input()); *p++ = c );
  228.             putbak(c);
  229.             *p = '\0';
  230.             return(lexsave(COLONVAR));
  231.             }
  232.         putbak(c);
  233.         return(lexsave(BINARY));
  234.         }
  235.  
  236.     if (c == '<') {            /* assign, less than or primitive */
  237.         *p++ = c; *p = '\0';
  238.         c = input();
  239.         if (c == '-')
  240.             return(token = ASSIGN);
  241.         for (p = q = "primitive"; *p && *p == c; p++)
  242.             c = input();
  243.         putbak(c);
  244.         if (*p) {
  245.             for (p--; p >= q; p--) putbak(*p);
  246.             return(lexsave(BINARY));
  247.             }
  248.         else 
  249.             return(token = PRIMITIVE);
  250.         }
  251.  
  252.     if (c == '.') {            /* number or period */
  253.         c = input();
  254.         if (c >= '0' && c <= '9') {
  255.             putbak(c);        /* reparse with digit */
  256.             putbak('.');        /* inserted on front */
  257.             putbak('0');        /* so it looks like */
  258.             return(nextlex());    /* a number */
  259.             }
  260.         putbak(c);
  261.         return(token = PERIOD);
  262.         }
  263.  
  264.     if (c == '\\') {        /* binary or hidden newline */
  265.         c = input();
  266.         if (c == '\n')
  267.             return(nextlex());
  268.         putbak(c);
  269.         return(lexsave(BINARY));
  270.         }
  271.  
  272.     if (c == '$') {            /* literal character or binary */
  273.         c = input();
  274.         if (c) {
  275.             t.i = c;
  276.             return(token = LITCHAR);
  277.             }
  278.         return(lexsave(BINARY));
  279.         }
  280.  
  281.     for (i = 0; symbols[i]; i++)
  282.         if (c == symbols[i])
  283.             return(lexsave(symval[i]));
  284.  
  285.     return(lexsave(BINARY));
  286. }
  287.